home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 051-075 / disk_058 / bigview / readilbm.c < prev    next >
C/C++ Source or Header  |  1992-05-06  |  7KB  |  255 lines
  1. #include "iff.h"
  2.  
  3. extern void *IntuitionBase,*GfxBase,*DiskfontBase;
  4.  
  5. /* READILBM.C : NewZAP support routines - (c) 1986 John Hodgson */
  6.  
  7. #define DISK_ERR   1  /* error processing */
  8. #define IFF_ERR    2
  9. #define OUT_OF_MEM 3
  10. #define EXPAND_ERR 4
  11. #define BAD_MODE   5
  12.  
  13. #define MakeID(a,b,c,d) ((a)<<24L | (b)<<16L | (c)<<8 | (d))
  14.  
  15. #define ID_FORM MakeID('F','O','R','M')
  16. #define ID_ILBM MakeID('I','L','B','M')
  17. #define ID_BMHD MakeID('B','M','H','D')
  18. #define ID_CAMG MakeID('C','A','M','G')
  19. #define ID_CMAP MakeID('C','M','A','P')
  20. #define ID_BODY MakeID('B','O','D','Y')
  21.  
  22. #define cmpByteRun1 1
  23.  
  24. #define ROUNDODDUP(a) (((a)+1)&(~1L))
  25.  
  26. typedef struct {
  27.   long ckID,ckSize;
  28. } Chunk;
  29.  
  30. typedef struct {
  31.   short w,h,x,y;
  32.   char  nPlanes,masking,compression,pad1;
  33.   short transparentColor;
  34.   char  xAspect, yAspect;
  35.   short pageWidth,pageHeight;
  36. } BitMapHeader;
  37.  
  38. short Mode;
  39. unsigned char *pdiskptr;
  40.  
  41. #define SafeRead(a,b,c) if (ReadNEW(a,b,c)==-1L) \
  42.   { CloseNEW(a); return(DISK_ERR); }
  43.  
  44. void *AllocMem(),*AllocRaster(); 
  45.  
  46. /************************************************************************
  47. *                                                                       *
  48. *    Routine name(s) : ReadILBM()                                       *
  49. *    Author          : D. John Hodgson                                  *
  50. *    Environment     : Aztec "C", default                               *
  51. *                                                                       *
  52. *    ReadILBM attempts to read an IFF file into an user-supplied        *
  53. *    bitmap. Returns TRUE if successful. Brushes supported.             *
  54. *                                                                       *
  55. *    OPTIONS : Filespec reflects user-supplied pointer to IFF file in   *
  56. *              RAM if mode argument is non-zero. Otherwise, disk.       *
  57. *                                                                       *
  58. *    LIMITATIONS : Bare-bones ILBM; no masking, CATS/LISTS/PROPS.       *
  59. *                  All other graphics (compressed or not) supported.    *
  60. ************************************************************************/
  61.  
  62. void *OpenNEW(name,accessMode)
  63. unsigned char *name;
  64. long accessMode;
  65. {
  66.   struct FileHandle *Open();
  67.  
  68.   if (!Mode) return(Open(name,accessMode));
  69.  
  70.   pdiskptr=name; /* initialize pseudo-disk RAM ptr */ 
  71.   return(pdiskptr);
  72. }
  73.  
  74. long ReadNEW(file,buffer,length)
  75. struct FileHandle *file;
  76. char *buffer;
  77. long length;
  78. {
  79.   long Read();
  80.  
  81.   if (!Mode) return(Read(file,buffer,length));
  82.  
  83.   movmem(pdiskptr,buffer,(unsigned int)length);
  84.   pdiskptr+=length;
  85.  
  86.   return(length);
  87. }
  88.  
  89. long SeekNEW(file,position,tmode)
  90. struct FileHandle *file;
  91. long position,tmode;
  92. {
  93.   long Seek();
  94.  
  95.   if (!Mode) return(Seek(file,position,tmode));
  96.  
  97.   /* Note : RAM seek only supports one mode : OFFSET_CURRENT! */
  98.   if (tmode!=OFFSET_CURRENT) return(BAD_MODE);
  99.     
  100.   pdiskptr+=position;
  101.  
  102.   return((long)pdiskptr-position); /* Seek() returns previous position! */
  103. } 
  104.  
  105. void CloseNEW(file)
  106. struct FileHandle *file;
  107. {
  108.   if (!Mode) Close(file);
  109. }
  110.  
  111. /* tag : core routines live here! */
  112.  
  113. ReadILBM(fspec,mode,picmap)
  114. char *fspec; /* AmigaDOS filename */
  115. short mode;
  116. struct PicMap *picmap;
  117. {
  118.   struct FileHandle *fp;
  119.   Chunk header;
  120.   BitMapHeader bmhd;
  121.   unsigned char colormap[MAXCOLORS][3],*bufstart,*sourcebuf;
  122.   short i;
  123.   long id;
  124.  
  125.   Mode=mode; 
  126.   setmem(picmap,sizeof(*picmap),0L);
  127.  
  128.   if (!(fp=OpenNEW(fspec,MODE_OLDFILE))) return(DISK_ERR);
  129.  
  130.   SafeRead(fp,&header,(long)sizeof(header));
  131.   if (header.ckID!=ID_FORM) { CloseNEW(fp); return(IFF_ERR); }
  132.  
  133.   SafeRead(fp,&id,(long)sizeof(id));
  134.   if (id!=ID_ILBM) { CloseNEW(fp); return(IFF_ERR); }
  135.  
  136.   for (;;) {
  137.     SafeRead(fp,&header,(long)sizeof(header));
  138.  
  139.     if (header.ckID==ID_BODY) break;
  140.  
  141.     switch(header.ckID) {
  142.       case ID_BMHD: SafeRead(fp,&bmhd,(long)sizeof(bmhd));
  143.  
  144.                     /* force WORD boundary for all pics */
  145.                     bmhd.w=(bmhd.w + 0xf) & 0xfff0;
  146.  
  147.                     break;
  148.  
  149.       case ID_CMAP: SafeRead(fp,&colormap[0][0],(long)header.ckSize);
  150.  
  151.                     for (i=0;i<header.ckSize/3;i++) 
  152.                       picmap->colormap[i]=colormap[i][2]>>4 |
  153.                                           colormap[i][1] & 0xf0 |
  154.                                           (colormap[i][0] & 0xf0)<<4;
  155.                     break;    
  156.  
  157.       case ID_CAMG: SafeRead(fp,&picmap->ViewModes,(long)header.ckSize);
  158.                     break;
  159.  
  160.       default:      SeekNEW(fp,ROUNDODDUP(header.ckSize),OFFSET_CURRENT);
  161.     }
  162.   }
  163.  
  164.   /* make some forced assumptions if CAMG chunk unavailable */
  165.  
  166.   if (!picmap->ViewModes) {
  167.     if (bmhd.w>LOWIDTH) picmap->ViewModes=HIRES;
  168.     if (bmhd.h>LOHEIGHT) picmap->ViewModes|=LACE;
  169.   }
  170.  
  171.   /* Read planes into RAM for ease if decompression */
  172.  
  173.   if (Mode) sourcebuf=bufstart=pdiskptr;  /* memory-resident IFF? */
  174.   else { /* disk-resident IFF? */
  175.     if (!(sourcebuf=bufstart=AllocMem((long)header.ckSize,MEMF_PUBLIC)))
  176.        return(OUT_OF_MEM);
  177.     SafeRead(fp,sourcebuf,(long)header.ckSize); CloseNEW(fp);  
  178.   }
  179.  
  180.   InitBitMap(&picmap->BitMap,(long)bmhd.nPlanes,(long)bmhd.w,(long)bmhd.h);
  181.  
  182.   /* if we -REALLY- need a blank page, zero after allocating! */
  183.  
  184.   for (i=0;i<bmhd.nPlanes;i++)
  185.     if (!(picmap->BitMap.Planes[i]=AllocRaster((long)bmhd.w,(long)bmhd.h))) {
  186.       FreeBitMap(&picmap->BitMap);
  187.       return(OUT_OF_MEM);
  188.     }
  189.  
  190.   i=Expand(&bmhd,bufstart,&picmap->BitMap);
  191.  
  192.   if (!Mode) FreeMem(bufstart,(long)header.ckSize);
  193.  
  194.   return(i); /* error if unpacking prob */
  195. }      
  196.  
  197. FreeBitMap(bitmap)
  198. struct BitMap *bitmap;
  199. {
  200.   short i;
  201.  
  202.   /* take into acct partially allocated maps (due to error) */
  203.  
  204.   for (i=0;i<bitmap->Depth;i++) {
  205.     if (bitmap->Planes[i]) FreeRaster(
  206.        bitmap->Planes[i],(long)bitmap->BytesPerRow*8,(long)bitmap->Rows);
  207.   }
  208.  
  209.   setmem(bitmap,sizeof(bitmap),0L); /* prevent dbl-dealloc errs */
  210. }
  211.  
  212. Expand(bmhd,sourcebuf,bitmap) /* Fast line decompress/deinterleave */
  213. BitMapHeader *bmhd;
  214. register char *sourcebuf;
  215. struct BitMap *bitmap;
  216. {
  217.   register char n,*destbuf; /* in order of preferred allocation */
  218.   register short plane,rowlen,rowbytes,i;
  219.  
  220.   rowlen=(bmhd->w)>>3;
  221.  
  222.   for (i=0;i<bmhd->h;i++) /* process n lines/screen */
  223.     for (plane=0;plane<bmhd->nPlanes;plane++) { /* process n planes/line */
  224.       destbuf=(char *)(bitmap->Planes[plane])+rowlen*i;
  225.  
  226.       if (bmhd->compression==cmpByteRun1) { /* compressed screen? */
  227.         rowbytes=rowlen;
  228.  
  229.         while (rowbytes>0) { /* unpack until 1 scan-line complete */
  230.           n=*sourcebuf++; /* fetch block run marker */
  231.  
  232.           /* uncompressed block? copy n bytes verbatim */
  233.           if (n>=0) {
  234.             ++n;
  235.             movmem(sourcebuf,destbuf,(unsigned int)n);
  236.             rowbytes-=n; destbuf+=n; sourcebuf+=n;
  237.           }
  238.           else { /* compressed block? expand n duplicate bytes */
  239.             n=-n+1;
  240.             setmem(destbuf,(unsigned int)n,(unsigned int)*sourcebuf);
  241.             rowbytes -=n; sourcebuf++; destbuf+=n;
  242.           }
  243.  
  244.         } /* finish unpacking line */
  245.         if (rowbytes) return(EXPAND_ERR); /* shouldn't be any left over! */
  246.       }
  247.       else { /* uncompressed? just copy */
  248.         movmem(sourcebuf,destbuf,(unsigned int)rowlen);
  249.         sourcebuf+=rowlen; destbuf+=rowlen;
  250.       }
  251.     } /* finish interleaved planes, lines */
  252.  
  253.   return(0); /* good result! */
  254. }
  255.